home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 19 / CU Amiga Magazine's Super CD-ROM 19 (1998)(EMAP Images)(GB)[!][issue 1998-02].iso / CUCD / Programming / LEDA / source / src / vga / _vgadraw.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-16  |  18.9 KB  |  965 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  _vgadraw.c
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16.  
  17. /* basic graphic routines of libWx  declared in <LEDA/impl/x_basic.h>) 
  18.  * iplemented for MSDOS using the VGA 640x480x16 color graphics mode
  19.  */
  20.  
  21. #include "vga.h"
  22. #include "vgafont"
  23.  
  24. static VIDEO_PTR video_buf;
  25. static int COLOR = 1;
  26. static int MODE  = 0;
  27. static int LINEWIDTH = 1;
  28. static int LINESTYLE = 0;
  29.  
  30.  
  31. void flush_display() {}
  32.  
  33. int  new_color(const char*) { return 1; }
  34.  
  35. int  text_height(const char*)  { return FONT_HEIGHT; }
  36. int  text_width(const char* s) { return FONT_WIDTH*strlen(s); }
  37.  
  38. int load_text_font(const char*) { return 0;}
  39. int load_bold_font(const char*) { return 0;}
  40. int load_message_font(const char*) { return 0;}
  41.  
  42. int  set_font(const char*) { return 0;}
  43. void set_text_font() {}
  44. void set_bold_font() {}
  45. void set_message_font() {}
  46.  
  47. int set_line_width(int width)
  48. { int save = LINEWIDTH;
  49.   LINEWIDTH = width;
  50.   return save;
  51. }
  52.  
  53. int set_line_style(int style)
  54. { int save = LINESTYLE;
  55.   LINESTYLE = style;
  56.   return save;
  57. }
  58.  
  59. int set_color(int color)
  60. {  int save = COLOR;
  61.    COLOR = color;
  62.    port_out(0x00, GRA_I );
  63.    port_out(color, GRA_D );
  64.    return save;
  65.  }
  66.  
  67. int set_mode(int mode)
  68. { int save = MODE;
  69.  
  70.   MODE = mode;
  71.  
  72.   if (mode==1)         mode = 3; /* xor */
  73.   else if (mode==2)    mode = 2; /* or  */
  74.      else if (mode==3) mode = 1; /* and */
  75.                   else mode = 0; /* src */
  76.  
  77.   port_out(0x03, GRA_I );
  78.   port_out(mode<<3, GRA_D );
  79.   return save;
  80. }
  81.  
  82.  
  83. static void put_pixel(VgaWindow win, int x, int y)
  84. { VIDEO_PTR p;
  85.  
  86.   if (x < 0 || x >= win->width || y < 0 || y >= win->height) return;
  87.  
  88.   x += win->xpos;
  89.   y += win->ypos;
  90.  
  91.   if (VIDEO==0)   /* write into (monochrome) buffer */
  92.      video_buf[y*LINE_BYTES+(x>>3)] |= (0x80 >> (x & 7));
  93.   else
  94.   { p = VIDEO + y*LINE_BYTES + (x>>3);
  95.     port_out(8, GRA_I);
  96.     port_out((0x80 >> (x & 7)), GRA_D);
  97.     *p = *p;
  98.    }
  99. }
  100.  
  101. static void vline(VgaWindow win,int x, int y0, int y1)
  102. { register VIDEO_PTR p;
  103.   register VIDEO_PTR last;
  104.  
  105.   if (y0 > y1)
  106.   { int y = y0;
  107.     y0 = y1;
  108.     y1 = y;
  109.    }
  110.  
  111.   if (x < 0 || x >= win->width || y1 < 0 || y0 >= win->height) return;
  112.  
  113.   if (y0 < 0) y0 = 0;
  114.   if (y1 >= win->height) y1 = win->height-1;
  115.  
  116.   x  += win->xpos;
  117.   y0 += win->ypos;
  118.   y1 += win->ypos;
  119.  
  120.   port_out(8, GRA_I);
  121.   port_out(128 >> (x&7), GRA_D);
  122.   last  = VIDEO + LINE_BYTES*y1 + (x>>3);
  123.   for(p = VIDEO + LINE_BYTES*y0 + (x>>3); p <= last; p+=LINE_BYTES)  *p = *p;
  124.  
  125. }
  126.  
  127.  
  128. static void hline(VgaWindow win, int x0, int x1, int y)
  129. { register VIDEO_PTR p;
  130.   register VIDEO_PTR first;
  131.   register VIDEO_PTR last;
  132.   char byte;
  133.  
  134.   if (x0 > x1)
  135.   { int x = x0;
  136.     x0 = x1;
  137.     x1 = x;
  138.    }
  139.   if (y < 0 || y >= win->height || x1 < 0 || x0 >= win->width) return;
  140.   if (x0 < 0) x0 = 0;
  141.   if (x1 >= win->width) x1 = win->width-1;
  142.  
  143.   x0 += win->xpos;
  144.   x1 += win->xpos;
  145.   y  += win->ypos;
  146.  
  147.  
  148.   if (x0 > DISP_MAX_X  || y > DISP_MAX_Y || y < 0) return;
  149.  
  150.   if (x1 > DISP_MAX_X) x1 = DISP_MAX_X;
  151.   if (x0 < 0) x0 = 0;
  152.  
  153.   first = VIDEO + LINE_BYTES*y + (x0>>3);
  154.   last  = VIDEO + LINE_BYTES*y + (x1>>3);
  155.  
  156.   port_out(8, GRA_I);
  157.  
  158.   if (first == last)
  159.   { byte  = 0xFF>>(x0&7);
  160.     byte &= 0xFF<<((~x1)&7);
  161.     port_out(byte, GRA_D);
  162.     *first = *first;
  163.     return;
  164.    }
  165.  
  166.   port_out(0xFF>>(x0&7), GRA_D);
  167.   *first = *first;
  168.  
  169.   port_out(0xFF<<((~x1)&7), GRA_D);
  170.   *last = *last;
  171.  
  172.   port_out(0xFF, GRA_D);
  173.   for(p=first+1; p<last; p++) *p = *p;
  174.  
  175.  }
  176.  
  177.  
  178. static void Draw_Line(VgaWindow win, int x1, int y1, int x2, int y2)
  179. {
  180.   register int sy = 1;
  181.   register int dx = x2 - x1;
  182.   register int dy = y2 - y1;
  183.   register int c;
  184.   int i;
  185.  
  186.   if (dx < 0)
  187.   { int i = x1;
  188.     x1 = x2;
  189.     x2 = i;
  190.     dx = -dx;
  191.     i = y1;
  192.     y1 = y2;
  193.     y2 = i;
  194.     dy = -dy;
  195.    }
  196.   if (dy < 0)
  197.   { dy = -dy;
  198.     sy = -1;
  199.    }
  200.  
  201.   if (dx > dy)
  202.   { c = dx / 2;
  203.     put_pixel(win,x1,y1);
  204.     for (i=1; i<=LINEWIDTH/2; i++)
  205.     { put_pixel(win,x1,y1+i);
  206.       put_pixel(win,x1,y1-i);
  207.      }
  208.     while(x1 != x2)
  209.     { x1++;
  210.       c += dy;
  211.       if (c >= dx)
  212.       { c -= dx;
  213.         y1 += sy;
  214.        }
  215.       put_pixel(win,x1,y1);
  216.       for (i=1; i<=LINEWIDTH/2; i++)
  217.       { put_pixel(win,x1,y1+i);
  218.         put_pixel(win,x1,y1-i);
  219.        }
  220.     }
  221.   }
  222.   else
  223.   { c = dy / 2;
  224.     put_pixel(win,x1,y1);
  225.     for (i=1; i<=LINEWIDTH/2; i++)
  226.     { put_pixel(win,x1+i,y1);
  227.       put_pixel(win,x1-i,y1);
  228.      }
  229.     while(y1 != y2)
  230.     { y1 += sy;
  231.       c += dx;
  232.       if (c >= dy)
  233.       { c -= dy;
  234.         x1++;
  235.        }
  236.       put_pixel(win,x1,y1);
  237.       for (i=1; i<=LINEWIDTH/2; i++)
  238.       { put_pixel(win,x1+i,y1);
  239.         put_pixel(win,x1-i,y1);
  240.        }
  241.     }
  242.   }
  243. }
  244.  
  245. void line(Window w, int x1, int y1, int x2, int y2)
  246. { int i;
  247.  
  248.   VgaWindow win = win_stack[w];
  249.  
  250.   if (x1 == x2)
  251.   { vline(win,x1,y1,y2);
  252.     for (i=1; i<=LINEWIDTH/2; i++)
  253.     { vline(win,x1-i,y1,y2);
  254.       vline(win,x1+i,y1,y2);
  255.      }
  256.     return;
  257.    }
  258.  
  259.   if (y1 == y2)
  260.   { hline(win,x1,x2,y1);
  261.     for (i=1; i<=LINEWIDTH/2; i++)
  262.     { hline(win,x1,x2,y1-i);
  263.       hline(win,x1,x2,y1+i);
  264.      }
  265.     return;
  266.    }
  267.  
  268.   Draw_Line(win,x1,y1,x2,y2);
  269. }
  270.  
  271.  
  272.  
  273. static int get_pixel(int x, int y)
  274. {
  275.   register int bit = 0x80 >> (x&7);
  276.   register VIDEO_PTR byte = VIDEO + LINE_BYTES*y+(x>>3);
  277.   register int c;
  278.  
  279.   if (x < 0 || x > DISP_MAX_X || y < 0 || y > DISP_MAX_Y) return 0;
  280.  
  281.   /* set read mode 1 */
  282.   port_out(5, GRA_I);
  283.   port_out(8, GRA_D);
  284.  
  285.   for(c=0; c<16; c++)
  286.   { port_out(2, GRA_I);
  287.     port_out(c, GRA_D);
  288.     if (*byte & bit)  break;
  289.    }
  290.  
  291.   return c;
  292. }
  293.  
  294.  
  295. #define FILLPUT(pos,byte)\
  296. { p = pos;\
  297.   if ((*p & (byte)) == 0)\
  298.   { *p |= (byte);\
  299.     POS[top] = p; \
  300.     BYTE[top] = byte; \
  301.     top = (top+1) % 512; } else;\
  302. }
  303.  
  304. static  VIDEO_PTR      POS[512];
  305. static  unsigned char  BYTE[512];
  306.  
  307. static void fill_bits(VIDEO_PTR pos,unsigned char byte)
  308. { register int bot = 0;
  309.   register int top = 0;
  310.   register VIDEO_PTR p;
  311.  
  312.   FILLPUT(pos,byte)
  313.  
  314.   while (top != bot)
  315.   { pos  = POS[bot];
  316.     byte = BYTE[bot];
  317.  
  318.     bot = (bot+1) % 512;
  319.  
  320.     if (byte == 128)
  321.        FILLPUT(pos-1,1)
  322.     else
  323.        FILLPUT(pos,byte<<1)
  324.  
  325.     if (byte == 1)
  326.        FILLPUT(pos+1,128)
  327.     else
  328.        FILLPUT(pos,byte>>1)
  329.  
  330.     FILLPUT(pos-LINE_BYTES,byte)
  331.     FILLPUT(pos+LINE_BYTES,byte)
  332.   }
  333. }
  334.  
  335. static  VIDEO_PTR  POS1[512];
  336. static  int pos_top = 0;
  337.  
  338. void fill_bytes(VIDEO_PTR pos, int d)
  339. { VIDEO_PTR p = pos+d;
  340.  
  341.   unsigned char c = *p;
  342.   unsigned char pat = 0xFF;
  343.  
  344.   if (c == 0)
  345.   { *p = 0xFF;
  346.     fill_bytes(p,  1);
  347.     fill_bytes(p, -1);
  348.     fill_bytes(p, LINE_BYTES);
  349.     fill_bytes(p,-LINE_BYTES);
  350.     return;
  351.    }
  352.  
  353.   if (d == -1)
  354.   { while((c&1) == 0)
  355.     { pat <<= 1;
  356.       c >>= 1;
  357.      }
  358.     *p |= ~pat;
  359.    }
  360.  
  361.   if (d == 1)
  362.   { while((c&128) == 0)
  363.     { pat >>= 1;
  364.       c <<= 1;
  365.      }
  366.     *p |= ~pat;
  367.    }
  368.  
  369.   if((c&8) == 0 && (d == LINE_BYTES || d == -LINE_BYTES))   POS1[pos_top++] = p;
  370.  
  371.  }
  372.  
  373.  
  374. void fill_polygon(Window w, int n, int* xcoord, int* ycoord)
  375. {
  376.   VgaWindow win = win_stack[w];
  377.  
  378.   register VIDEO_PTR p;
  379.   register VIDEO_PTR q;
  380.   register VIDEO_PTR first;
  381.   register VIDEO_PTR first1;
  382.   register VIDEO_PTR last;
  383.  
  384.   int i,m1,m2;
  385.   int minxi = 0;
  386.   int maxxi = 0;
  387.   int minyi = 0;
  388.   int maxyi = 0;
  389.   int minx,maxx,miny,maxy,x,y;
  390.  
  391.   VIDEO_PTR video_save = VIDEO;
  392.  
  393.   VIDEO = 0;
  394.  
  395.   video_buf = (VIDEO_PTR)malloc(LINE_BYTES*480);
  396.  
  397.  
  398.   for(i=1;i<n;i++)
  399.   { minxi = (xcoord[i] < xcoord[minxi]) ? i : minxi;
  400.     minyi = (ycoord[i] < ycoord[minyi]) ? i : minyi;
  401.     maxxi = (xcoord[i] > xcoord[maxxi]) ? i : maxxi;
  402.     maxyi = (ycoord[i] > ycoord[maxyi]) ? i : maxyi;
  403.    }
  404.  
  405.   minx = (xcoord[minxi] + win->xpos)/8;
  406.   maxx = (xcoord[maxxi] + win->xpos)/8;
  407.   miny = ycoord[minyi] + win->ypos;
  408.   maxy = ycoord[maxyi] + win->ypos;
  409.  
  410.   m1 =  (minxi == 0)   ?  n-1 : minxi-1;
  411.   m2 =  (minxi == n-1) ?  0   : minxi+1;
  412.  
  413.   for(i=miny; i<=maxy; i++)
  414.   { last = video_buf+LINE_BYTES*i + maxx;
  415.     for(p=video_buf+LINE_BYTES*i+minx; p<=last; p++) *p= 0;
  416.    }
  417.  
  418.   for(i=0; i<n-1; i++)
  419.       Draw_Line(win,xcoord[i],ycoord[i],xcoord[i+1],ycoord[i+1]);
  420.  
  421.   Draw_Line(win,xcoord[0],ycoord[0],xcoord[n-1],ycoord[n-1]);
  422.  
  423.   x = (xcoord[m1] + xcoord[m2] + xcoord[minxi])/3 + win->xpos;
  424.   y = (ycoord[m1] + ycoord[m2] + ycoord[minxi])/3 + win->ypos;
  425.  
  426.   pos_top = 0;
  427.   fill_bytes(video_buf + LINE_BYTES*y + x/8,0);
  428.  
  429.   while (pos_top--) fill_bits(POS1[pos_top],8);
  430.  
  431.   fill_bits(video_buf+LINE_BYTES*y+x/8,128>>(x%8));
  432.  
  433.   VIDEO = video_save;
  434.  
  435.   first  = video_buf+LINE_BYTES*miny + minx;
  436.   first1 = VIDEO+LINE_BYTES*miny + minx;
  437.   last   = video_buf+LINE_BYTES*miny + maxx;
  438.  
  439.   port_out(8, GRA_I);
  440.  
  441.   while(miny <= maxy)
  442.   { for(p=first, q = first1; p<=last; p++, q++)
  443.     { port_out(*p, GRA_D);
  444.       *q = *q;
  445.      }
  446.     first  += LINE_BYTES;
  447.     first1 += LINE_BYTES;
  448.     last   += LINE_BYTES;
  449.     miny++;
  450.    }
  451.  
  452.   free((char*)video_buf);
  453. }
  454.  
  455.  
  456. void box(Window w, int x0, int y0, int x1, int y1)
  457. { VgaWindow win = win_stack[w];
  458.   if (y0 > y1)
  459.   { int y = y0;
  460.     y0 = y1;
  461.     y1 = y;
  462.    }
  463.   while(y0<=y1) hline(win,x0,x1,y0++);
  464.  }
  465.  
  466.  
  467. void  rectangle(Window w, int x0, int y0, int x1, int y1)
  468. { 
  469.   int left  = x0;
  470.   int right = x1;
  471.   int top   = y0;
  472.   int bottom= y1;
  473.  
  474.   if (x0 > x1)
  475.   { left  = x1;
  476.     right = x0;
  477.    }
  478.  
  479.   if (y0 > y1)
  480.   { top  = y1;
  481.     bottom = y0;
  482.    }
  483.  
  484.   line(w,left, top,     right,top);
  485.   line(w,left, bottom,  right,bottom);
  486.   line(w,left, bottom-1,left, top+1);
  487.   line(w,right,bottom-1,right,top+1);
  488. }
  489.  
  490.  
  491. void circle(Window w, int x0,int y0,int r0)
  492. { VgaWindow win = win_stack[w];
  493.   int r;
  494.  
  495.   for (r = r0-LINEWIDTH/2; r <= r0+LINEWIDTH/2; r++)
  496.   { int y = r;
  497.     int x = 0;
  498.     int e = 3-2*y;
  499.  
  500.     put_pixel(win,x0,y0+r);
  501.     put_pixel(win,x0,y0-r);
  502.     put_pixel(win,x0+r,y0);
  503.     put_pixel(win,x0-r,y0);
  504.  
  505.     for (x=1;x<y;)
  506.       { put_pixel(win,x0+x,y0+y);
  507.         put_pixel(win,x0+x,y0-y);
  508.         put_pixel(win,x0-x,y0+y);
  509.         put_pixel(win,x0-x,y0-y);
  510.         put_pixel(win,x0+y,y0+x);
  511.         put_pixel(win,x0+y,y0-x);
  512.         put_pixel(win,x0-y,y0+x);
  513.         put_pixel(win,x0-y,y0-x);
  514.         x++;
  515.         if (e>=0) { y--; e = e - 4*y; }
  516.         e = e + 4*x + 2;
  517.        }
  518.  
  519.     if (x == y)
  520.     { put_pixel(win,x0+x,y0+y);
  521.       put_pixel(win,x0+x,y0-y);
  522.       put_pixel(win,x0-x,y0+y);
  523.       put_pixel(win,x0-x,y0-y);
  524.      }
  525.   }
  526. }
  527.  
  528.  
  529. void fill_circle(Window w, int x0, int y0, int r)
  530. { VgaWindow win = win_stack[w];
  531.   int y = 1;
  532.   int x = r;
  533.   int e = 3-2*r;
  534.  
  535.   hline(win,x0-x,x0+x,y0);
  536.  
  537.   while (y<=x)
  538.   { hline(win,x0-x,x0+x,y0+y);
  539.     hline(win,x0-x,x0+x,y0-y);
  540.  
  541.     if (y<x && e>=0)
  542.     { hline(win,x0-y,x0+y,y0+x);
  543.       hline(win,x0-y,x0+y,y0-x);
  544.       x--;
  545.       e = e - 4*x;
  546.      }
  547.     y++;
  548.     e = e + 4*y + 2;
  549.    }
  550. }
  551.  
  552.  
  553.  
  554. static void Put_Text(VgaWindow win, int x, int y, const char *str, int bg_col)
  555. { /* bgcol = -1 : transparent */
  556.   register unsigned char *fp1;
  557.   register unsigned char *fp2;
  558.   register unsigned char c;
  559.  
  560.   register VIDEO_PTR start;
  561.   register VIDEO_PTR stop;
  562.   register VIDEO_PTR q;
  563.  
  564.   char text[128];
  565.   int dy,i;
  566.   int len = strlen(str);
  567.   int l = (win->width-x)/text_width("H");
  568.   if (len > l) len = l;
  569.   if (len > 0) strncpy(text,str,len);
  570.   text[len] = 0;
  571.  
  572.  
  573.   if (y < 0 || y >= win->height || x < 0 || x >= win->width) return;
  574.  
  575.   if (bg_col >= 0)
  576.   { int save_color = set_color(bg_col);
  577.     int save_mode = set_mode(0);
  578.     box(win->id,x,y,x+text_width(text)-1,y+text_height(text)-1);
  579.     set_mode(save_mode);
  580.     set_color(save_color);
  581.    }
  582.  
  583.   dy = win->height - y;
  584.  
  585.   if (dy > FONT_HEIGHT) dy = FONT_HEIGHT;
  586.  
  587.   x += win->xpos;
  588.   y += win->ypos;
  589.  
  590.   fp1 = FONT + FONT_HEIGHT * ' ';
  591.   fp2 = FONT + FONT_HEIGHT * (text[0] & 127);
  592.  
  593.   start = VIDEO + LINE_BYTES*y + x/8;
  594.   stop = start + LINE_BYTES*dy;
  595.  
  596.   x &= 7;
  597.  
  598.   port_out(8, GRA_I);
  599.  
  600.   for(i=0;i<len; i++)
  601.   { for (q = start; q < stop; q+=LINE_BYTES, fp1++,fp2++)
  602.     { c = ((*fp2)>>x) | ((*fp1)<<(8-x));
  603.       port_out(c, GRA_D);
  604.       *q = *q;
  605.      }
  606.     fp1 = FONT + FONT_HEIGHT * (text[i] & 127);
  607.     fp2 = FONT + FONT_HEIGHT * (text[i+1] & 127);
  608.     start++;
  609.     stop++;
  610.    }
  611.  
  612.   if (x > 0)
  613.     for (q = start; q < stop; q+=LINE_BYTES, fp1++,fp2++)
  614.     { c = (*fp1)<<(8-x);
  615.       port_out(c, GRA_D);
  616.       *q = *q;
  617.      }
  618.  
  619. }
  620.  
  621. void put_text(Window w, int x, int y, const char *text, int opaque)
  622. { VgaWindow win = win_stack[w];
  623.   Put_Text(win,x,y,text,opaque ? win->bg_col : -1); }
  624.  
  625.  
  626. void put_ctext(Window w, int x, int y, const char* str, int opaque)
  627. { put_text(w,x-(text_width(str)-1)/2, y-(text_height(str)-1)/2, str, opaque);
  628.  }
  629.  
  630.  
  631. void show_coordinates(Window w, const char* s)
  632. { VgaWindow win = win_stack[w];
  633.   int save_mode = set_mode(0);
  634.   int save_col  = set_color(4);
  635.   put_text(w,win->width-138,1,s,1); 
  636.   set_mode(save_mode);
  637.   set_color(save_col);
  638. }
  639.  
  640.  
  641. void clear_window(Window w, int c)
  642. { VgaWindow win = win_stack[w];
  643.   int save_col  = set_color(win->bg_col);
  644.   int save_mode = set_mode(0);
  645.   box(w,0,0,win->width-1,win->height-1);
  646.   set_color(save_col);
  647.   set_mode(save_mode);
  648.  }
  649.  
  650.  
  651. void pixel(Window w, int x, int y) { put_pixel(win_stack[w],x,y);}
  652.  
  653. void pixels(Window w, int n, int* x, int* y)
  654. { while(n--) put_pixel(win_stack[w],x[n],y[n]); }
  655.  
  656.  
  657.  
  658. #define put_arc_pixel(X,Y,x,y,top) { X[top] = x; Y[top] = y; top++; }
  659.  
  660. void arc(Window w, int x0, int y0, int r1, int r2, double start, double angle)
  661. { VgaWindow win = win_stack[w];
  662.   int* X = new int[10*r1];
  663.   int* Y = new int[10*r2];
  664.   int r;
  665.  
  666.  x0 += win->xpos;
  667.  y0 += win->ypos;
  668.  
  669.  if (angle < 0)
  670.  { start += angle;
  671.    angle *= -1;
  672.   }
  673.  
  674.  if (angle > 2*M_PI) angle = 2*M_PI;
  675.  
  676.  while (start < 0) start += 2*M_PI;
  677.  
  678.  for (r = r1-LINEWIDTH/2; r <= r1+LINEWIDTH/2; r++)
  679.  { int y = r;
  680.    int x = 0;
  681.    int e = 3-2*y;
  682.    int top = 0;
  683.    int high;
  684.    int high1;
  685.    int s,l;
  686.    float L;
  687.    int i;
  688.  
  689.    while (x < y)
  690.    { put_arc_pixel(X,Y,x,y,top);
  691.      x++;
  692.      if (e>=0) { y--; e -= 4*y; }
  693.      e += 4*x + 2;
  694.     }
  695.  
  696.    high = top-1;
  697.  
  698.    if (x==y) put_arc_pixel(X,Y,x,y,top);
  699.  
  700.    high1 = top;
  701.  
  702.    for(i = 0;    i < high1; i++) put_arc_pixel(X,Y, Y[i],-X[i],top);
  703.    for(i = high; i > 0;     i--) put_arc_pixel(X,Y, X[i],-Y[i],top);
  704.    for(i = 0;    i < high1; i++) put_arc_pixel(X,Y,-X[i],-Y[i],top);
  705.    for(i = high; i > 0;     i--) put_arc_pixel(X,Y,-Y[i],-X[i],top);
  706.    for(i = 0;    i < high1; i++) put_arc_pixel(X,Y,-Y[i], X[i],top);
  707.    for(i = high; i > 0;     i--) put_arc_pixel(X,Y,-X[i], Y[i],top);
  708.    for(i = 0;    i < high1; i++) put_arc_pixel(X,Y, X[i], Y[i],top);
  709.    for(i = high; i > 0;     i--) put_arc_pixel(X,Y, Y[i], X[i],top);
  710.  
  711.    L = (top - high1)/(2*M_PI);
  712.    s = high1 - 1 + (int)(start*L);
  713.    l = s + (int)(angle*L);
  714.  
  715.    if (l >= top)
  716.    { for(i=s; i < top; i++) put_pixel(win,x0+X[i],y0+Y[i]);
  717.      s = high - 1;
  718.      l = s + l - top;
  719.     }
  720.    for(i=s; i < l; i++) put_pixel(win,x0+X[i],y0+Y[i]);
  721.   }
  722.  
  723.   delete X;
  724.   delete Y;
  725. }
  726.  
  727.  
  728. static void ellipse_point(VgaWindow win, int x0, int y0, int x, int y)
  729. { put_pixel(win,x0+x,y0+y);
  730.   put_pixel(win,x0-x,y0+y);
  731.   put_pixel(win,x0+x,y0-y);
  732.   put_pixel(win,x0-x,y0-y);
  733.  }
  734.  
  735.  
  736. void ellipse(Window w, int x0, int y0, int a, int b)
  737. { 
  738.   /* Foley, van Dam, Feiner, Huges: Computer Graphics, page 90 */
  739.  
  740.   VgaWindow win = win_stack[w];
  741.  
  742.   double d1,d2;
  743.   int x,y;
  744.   int a_2 = a*a;
  745.   int b_2 = b*b;
  746.  
  747.   put_pixel(win,x0,y0-b);
  748.   put_pixel(win,x0,y0+b);
  749.   put_pixel(win,x0-a,y0);
  750.   put_pixel(win,x0+a,y0);
  751.  
  752.   x = 0;
  753.   y = b;
  754.  
  755.   d1 = b*b + a*a*(0.25 - b); 
  756.    
  757.   while (a_2*(y - 0.5) > b_2*(x+1))
  758.   { if (d1 < 0)
  759.       d1 += b_2*(2*x + 3);
  760.     else
  761.     { d1 += b_2*(2*x + 3) + a_2*(2 - 2*y);
  762.       y--;
  763.      }
  764.     x++;
  765.     ellipse_point(win,x0,y0,x,y);
  766.   }
  767.  
  768.   d2 = b_2*(x+0.5)*(x+0.5) + a_2*(y - 1)*(y - 1) - a_2*b_2;
  769.  
  770.   while (y > 1)
  771.   { if (d2 < 0)
  772.      { d2 += b_2*(2*x+2)+a_2*(3-2*y);
  773.        x++;
  774.       }
  775.     else
  776.        d2 += a*a*(3-2*y);
  777.  
  778.     y--;
  779.  
  780.     ellipse_point(win,x0,y0,x,y);
  781.    }
  782. }
  783.  
  784.  
  785. void fill_ellipse(Window w, int x0, int y0, int a, int b)
  786. { VgaWindow win = win_stack[w];
  787.   double d1,d2;
  788.   int x,y;
  789.   int a_2 = a*a;
  790.   int b_2 = b*b;
  791.  
  792.   x = 0;
  793.   y = b;
  794.  
  795.   d1 = b*b + a*a*(0.25 - b); 
  796.    
  797.   while (a_2*(y - 0.5) > b_2*(x+1))
  798.   { if (d1 < 0)
  799.       d1 += b_2*(2*x + 3);
  800.     else
  801.     { d1 += b_2*(2*x + 3) + a_2*(2 - 2*y);
  802.       hline(win,x0-x,x0+x,y0+y);
  803.       hline(win,x0-x,x0+x,y0-y);
  804.       y--;
  805.      }
  806.     x++;
  807.   }
  808.   hline(win,x0-x,x0+x,y0+y);
  809.   hline(win,x0-x,x0+x,y0-y);
  810.  
  811.   d2 = b_2*(x+0.5)*(x+0.5) + a_2*(y - 1)*(y - 1) - a_2*b_2;
  812.  
  813.   while (y > 1)
  814.   { if (d2 < 0)
  815.      { d2 += b_2*(2*x+2)+a_2*(3-2*y);
  816.        x++;
  817.       }
  818.     else
  819.        d2 += a*a*(3-2*y);
  820.  
  821.     y--;
  822.  
  823.     hline(win,x0-x,x0+x,y0+y);
  824.     hline(win,x0-x,x0+x,y0-y);
  825.    }
  826.  
  827.   hline(win,x0-x,x0+x,y0);
  828.  
  829. }
  830.  
  831.  
  832. void fill_arc(Window,int,int,int,int,double,double)
  833. { }
  834.  
  835.  
  836. static void copy_box(int left, int top, int width, int height, int x, int y)
  837. {
  838.   register VIDEO_PTR first1;
  839.   register VIDEO_PTR first;
  840.   register VIDEO_PTR last1;
  841.   register VIDEO_PTR last;
  842.   register VIDEO_PTR p;
  843.   register VIDEO_PTR q;
  844.  
  845.   int i;
  846.  
  847.   if(x < 0) 
  848.   { left += x;
  849.     width -= x;
  850.     x = 0;
  851.    }
  852.  
  853.   if(y < 0) 
  854.   { top += y;
  855.     height -= y;
  856.     y = 0;
  857.    }
  858.  
  859.   if(x+width > DISP_MAX_X) width = DISP_MAX_X - x;
  860.  
  861.   if(y+height > DISP_MAX_Y) height = DISP_MAX_Y - y;
  862.  
  863.   /* set write mode 1 */
  864.   port_out(5, GRA_I);
  865.   port_out(1, GRA_D);
  866.  
  867.   if (y <= top)
  868.   { first1 = VIDEO + LINE_BYTES*y + x/8;
  869.     last1  = VIDEO + LINE_BYTES*y + (x+width-1)/8;
  870.     first  = VIDEO + LINE_BYTES*top + left/8;
  871.     last   = VIDEO + LINE_BYTES*top + (left+width-1)/8;
  872.    }
  873.   else
  874.   { first1 = VIDEO + LINE_BYTES*(y+height-1) + x/8;
  875.     last1  = VIDEO + LINE_BYTES*(y+height-1) + (x+width-1)/8;
  876.     first  = VIDEO + LINE_BYTES*(top+height-1) + left/8;
  877.     last   = VIDEO + LINE_BYTES*(top+height-1) + (left+width-1)/8;
  878.    }
  879.  
  880.   for(i=0; i<height; i++)
  881.   { 
  882.     if (x <= left)
  883.       for(q=first, p=first1; q<=last; q++,p++) *p = *q;
  884.     else
  885.       for(q=last, p=last1; q>=first; q--,p--) *p = *q;
  886.  
  887.     if (y <= top)
  888.     { first1 += LINE_BYTES;
  889.       first  += LINE_BYTES;
  890.       last1  += LINE_BYTES;
  891.       last   += LINE_BYTES;
  892.      }
  893.     else
  894.     { first1 -= LINE_BYTES;
  895.       first  -= LINE_BYTES;
  896.       last1  -= LINE_BYTES;
  897.       last   -= LINE_BYTES;
  898.      }
  899.    }
  900.  
  901.   /* set write mode 0 */
  902.   port_out(5, GRA_I);
  903.   port_out(0, GRA_D);
  904.  
  905.  }
  906.  
  907. void copy_rect(Window w, int x1, int y1, int x2, int y2, int x, int y)
  908. { VgaWindow win = win_stack[w];
  909.   int width = x2-x1+1;
  910.   int height = y2-y1+1;
  911.   x1 += win->xpos; 
  912.   y1 += win->ypos; 
  913.   x  += win->xpos; 
  914.   y  += win->ypos; 
  915.   copy_box(x1,y1,width,height,x,y); 
  916.  }
  917.  
  918.  
  919. static char rev_byte(char c)
  920. { char c1 = 0x00;
  921.    for(int i=0; i<8; i++)
  922.    { c1 <<= 1;
  923.      if (c&1) c1 |= 1;
  924.      c >>= 1;
  925.     }
  926.   return c1;
  927. }
  928.  
  929.  
  930. void insert_bitmap(Window w, int width, int height, char* data)
  931. {
  932.   register VIDEO_PTR first;
  933.   register VIDEO_PTR last;
  934.   register VIDEO_PTR q;
  935.  
  936.   VgaWindow win = win_stack[w];
  937.  
  938.   int x = win->x0/8 + 1;
  939.   int y = win->ypos;
  940.  
  941.   int wi = (width > win->width) ? win->width : width;
  942.   int he = (height > win->height) ? win->height : height;
  943.  
  944.   first  = VIDEO + LINE_BYTES*y + x;
  945.   last   = VIDEO + LINE_BYTES*y + x + wi/8 - 1;
  946.  
  947.   if (width % 8)
  948.      width  = 1+ width/8;
  949.   else
  950.      width  = width/8;
  951.  
  952.   port_out(8, GRA_I);
  953.  
  954.   for(int i=0; i<he; i++)
  955.   { char* p = data + i*width;
  956.     for(q=first; q<=last; q++) 
  957.     { port_out(rev_byte(*p++), GRA_D);
  958.       *q = *q;
  959.      }
  960.     first += LINE_BYTES;
  961.     last  += LINE_BYTES;
  962.    }
  963.  }
  964.  
  965.